package code.rocky.chapter03;

public class Suggest40 {

    public static void main(String[] args) {
        // 接收两个参数1和2,然后设置一个操作符号,计算其值,结果是3
        // 带有参数的匿名类声明时到底是调用的哪一个构造函数
        Calculator c1 = new Calculator(1, 2) {
            {
                setOperator(Ops.ADD);
            }
        };
        System.out.println(c1.getResult());

        Calculator c2 = new ADD(1, 2) {
            {
                setOperator(Ops.ADD);
            }
        };
        System.out.println(c2.getResult());

        Calculator c3 = new ADD1(1, 2) {
            {
                setOperator(Ops.ADD);
            }
        };
        System.out.println(c3.getResult());
    }
}

enum Ops {
    ADD,
    SUB
}
class Calculator {
    private int i, j, result;

    public Calculator() {}

    public Calculator(int _i, int _j) {
        i = _i;
        j = _j;
    }

    protected void setOperator(Ops _op) {
        System.out.println("Calculator");
        result = _op.equals(Ops.ADD) ? i + j : i - j;
    }

    public int getResult() {
        return result;
    }
}

class ADD extends Calculator {
    {
        System.out.println("ADD");
        setOperator(Ops.ADD);
    }
    // 覆写父类的构造方法
    public ADD(int _i, int _j) {
        System.out.println("ADD(int _i, int _j)");
    }
}

class ADD1 extends Calculator {
    {
        System.out.println("ADD1");
        setOperator(Ops.ADD);
    }
    // 覆写父类的构造方法
    public ADD1(int _i, int _j) {
        super(_i, _j);
        System.out.println("ADD1(int _i, int _j)");
    }
}

